﻿'Une requête est construite à partir d'une table source
'Ensuite, les correspondances à inclure dans le SELECT sont ajoutée par l'intermédiaire
'de leur clé (identifiant de la correspondance dans le mapping de la table).
Imports System.Data.OleDb
Imports PTIC_Util

''' <summary>
''' Requête
''' </summary>
''' <remarks></remarks>
Public Class RequeteBDD
    Inherits Traitement

#Region "Variables globales"
    Protected _nomLibrairie As String

    'En entrée, une requête prend en paramètre différents traitements
    'Des correspondances issues de ces traitements sont utilisées pour définir la requête
    'Une modification sur l'une des correspondances doit être propagée partout si elle
    'intervient dans un group By, ou dans un Where mais pas partout si elle intervient dans un SELECT
    Protected _ltraitementsSource As Dictionary(Of String, Traitement)
    Protected _tbleSource As tableBDD

    Protected _isDISTINCT As Boolean
    Protected _lstCorrespGroupBy As Dictionary(Of String, Correspondance)
    Protected _lstJointures As New List(Of jointureBDD)
    Protected _lstWHERE As New Dictionary(Of String, expressionFiltreBDD)

    Protected _nbEnregistrements As Integer
#End Region

#Region "Propriétés"
    ''' <summary>
    ''' Nombre d'enregistrements du résultat de la requête
    ''' </summary>
    ''' <remarks></remarks>
    Public Property nbEnregistrements() As Integer
        Get
            Return _nbEnregistrements
        End Get
        Set(ByVal value As Integer)
            _nbEnregistrements = value
        End Set
    End Property

    ''' <summary>
    ''' Egal à true si IsDISTINCT doit figurer après le SELECT, false sinon
    ''' </summary>
    ''' <remarks></remarks>
    Public Property isDISTINCT() As Boolean
        Get
            Return _isDISTINCT
        End Get
        Set(ByVal value As Boolean)
            _isDISTINCT = value
        End Set
    End Property

    ''' <summary>
    ''' Liste des champs présents en sortie de la requête
    ''' </summary>
    ''' <remarks></remarks>
    Public Overloads Property ListeChampsSortie() As ListeChampsSortieRequete
        Get
            Return MyBase.ListeChampsSortie
        End Get
        Set(ByVal value As ListeChampsSortieRequete)
            MyBase.SetListeChampsSortie(value)
        End Set
    End Property

    ''' <summary>
    ''' Liste des traitements utilisés par la clause FROM de la requête
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property TraitementsSource As Dictionary(Of String, Traitement)
        Get
            Return _ltraitementsSource
        End Get
    End Property

#End Region

#Region "Constructeur"

    ''' <summary>
    ''' Constructeur spécifique pour une requête sur le mapping en entrée d'une tableBDD
    ''' </summary>
    ''' <param name="tbleSource"></param>
    ''' <param name="nom"></param>
    ''' <remarks></remarks>
    Protected Friend Sub New(ByVal tbleSource As tableBDD, ByVal nom As String)
        MyBase.New(nom)
        _ltraitementsSource = New Dictionary(Of String, Traitement)
        _ltraitementsSource.Add(tbleSource.nom, tbleSource)
        _tbleSource = tbleSource
        Connection = _tbleSource.Connection()
        _isDISTINCT = True
        ListeChampsSortie = New ListeChampsSortieRequete()
        _lstCorrespGroupBy = New Dictionary(Of String, Correspondance)
        _nbEnregistrements = 0
    End Sub

    ''' <summary>
    ''' Création d'une instance requeteBDD
    ''' </summary>
    ''' <param name="nom">Nom de la requête</param>
    ''' <param name="nomCompletTableResultat">Nom complet de la table physique contenant le résultat de la requête</param>
    ''' <param name="nomLib">Nom de la librairie SAS faisant référence au dossier contenant la table physique</param>
    ''' <param name="connection">Connection OLEdb vers l'environnement de travail SAS</param>
    ''' <remarks></remarks>
    Public Sub New(ByVal nom As String, _
                   ByVal nomCompletTableResultat As Cla_NomFichier, _
                   ByVal nomLib As String, _
                   ByVal connection As OleDbConnection)

        MyBase.New(nom, nomCompletTableResultat, nomCompletTableResultat.NomSansExt)
        Me.Connection = connection
        _nomLibrairie = nomLib
        _ltraitementsSource = New Dictionary(Of String, Traitement)

        _isDISTINCT = True
        ListeChampsSortie = New ListeChampsSortieRequete()
        _lstCorrespGroupBy = New Dictionary(Of String, Correspondance)
        _nbEnregistrements = 0
    End Sub

#End Region

#Region "Traitements des évènements Changement Nom de Table"
    Protected Sub onNomTableDansBDDget(ByVal sender As Object, ByVal e As PropertyGetEventArgs(Of String)) Handles Me.NomTableDansBDDGet
        e.returnValue = _nomLibrairie & "." & e.propertyValue
    End Sub
#End Region

#Region "Gestion des traitements constitutifs"
    ''' <summary>
    ''' Ajout d'un traitement en entrée de la requête
    ''' </summary>
    ''' <remarks>Le traitement apparait dans la clause FROM du code SQL de la requête</remarks>
    Public Sub addTraitementConstitutif(ByVal trait As Traitement)
        'Permet de gérer les dépendances avec les traitements en entrée de la requête
        FonctionCalculDataTable.AjouteFonctionCalculIntermediaire(trait.FonctionCalculBDD)
        FonctionCalculBDD.AjouteFonctionCalculIntermediaire(trait.FonctionCalculBDD)
        _ltraitementsSource.Add(trait.nom, trait)
    End Sub
#End Region

#Region "Méthodes - constitution de la requête"

#Region "Ancienne Version - Spécifique fonctionnement librairie"
    ''' <summary>
    ''' Ajoute un champs dans la clause SELECT de la requête
    ''' </summary>
    ''' <remarks></remarks>
    Protected Friend Overloads Sub addSELECT(ByVal c As Correspondance)
        Dim correspSELECT As Correspondance = c.copy
        correspSELECT.addCorrespConstitutive(c)
        ListeChampsSortie.addCorresp(correspSELECT.copy)
    End Sub

    ''' <summary>
    ''' Ajoute un champs dans la clause GROUP BY de la requête
    ''' </summary>
    ''' <remarks></remarks>
    Protected Friend Overloads Sub addGROUPBY(ByVal corresp As Correspondance)
        _lstCorrespGroupBy.Add(corresp.description, corresp)
        _lDependanceCorrespondances.Add(corresp)
        FonctionCalculDataTable.Invalider()
    End Sub
#End Region

#Region "La clause SELECT"

    Public Overloads Function addSELECT(ByVal nomCorresp As String)
        Dim nbOccurenceNom As Integer = 0
        Dim nomTraitement As String = ""
        For Each traitementSource As Traitement In _ltraitementsSource.Values
            If traitementSource.ListeChampsSortie.ContainsKey(nomCorresp) Then
                nbOccurenceNom = nbOccurenceNom + 1
                nomTraitement = traitementSource.nom
            End If
        Next
        If nbOccurenceNom = 1 Then
            addSELECT(nomTraitement, nomCorresp)
            Return True
        Else
            Return False
        End If
    End Function

    ''' <summary>
    ''' Ajout d'un champs présent en sortie d'un traitement source dans le SELECT de la requête
    ''' </summary>
    ''' <param name="nomTraitement">Nom du traitement contenant la correspondance à ajouter</param>
    ''' <param name="nomCorresp">Nom de la correspondance à ajouter dans le traitement source</param>
    ''' <remarks></remarks>
    Public Overloads Function addSELECT(ByVal nomTraitement As String, _
                                        ByVal nomCorresp As String, _
                                        Optional ByVal nomCorrespCible As String = "", _
                                        Optional ByVal descrCorrespCible As String = "") As Correspondance
        'Lorsqu'un champs est ajouté au SELECT ou au GROUP BY de la requête, cette dernière est bien
        'entendu invalidée
        Dim traitTest As Traitement = _ltraitementsSource(nomTraitement)
        Dim correspSELECT As Correspondance = _ltraitementsSource(nomTraitement).ListeChampsSortie(nomCorresp).copy()
        If nomCorrespCible <> "" Then
            correspSELECT.chOutil.Nom = nomCorrespCible
        End If
        If descrCorrespCible <> "" Then
            correspSELECT.description = descrCorrespCible
        End If
        correspSELECT.setTraitement(Me)
        Dim chSource As ChampsBDD = New ChampsBDD("{1}", correspSELECT.chOutil.Format.copy)
        correspSELECT.setChEntree(chSource)
        ListeChampsSortie.addCorresp(correspSELECT)

        correspSELECT.clearCorrespConstitutive()
        correspSELECT.clearCorrespFormule()

        'Ajout de la correspondance source comme correspondance constitutive du nouveau champs créé en sortie
        correspSELECT.addCorrespFormule(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(nomCorresp))
        'Il faut également ajouter en correspondance constitutive toutes celles qui interviennent dans le group
        'BY ainsi que celle qui interviennent dans le WHERE (ou le HAVING d'ailleurs)

        'Interception, à l'intérieur du traitement, des messages d'invalidation du champs source
        addDependance(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(nomCorresp))


        'Ajout de la correspondance au mapping de sortie de la requête
        'Il s'agit du mapping dans lequel un traitement ultérieur ira récupérer ses champs
        'Le mapping de sortie en sortie contient la collection correspSELECT
        '_mapSortie.addCorresp(corresp)
        invalideAll()
        'Interception de l'évènement "la correspondance a été modifiée"

        Return correspSELECT
    End Function

    ''' <summary>
    ''' Ajoute une correspondance calculée à la requête
    ''' </summary>
    ''' <param name="lnomsTraitementsSource">Liste des traitements source intervenant dans la formule de calcul</param>
    ''' <param name="ldescCorrespFormule">Description des correspondances intervenant dans la formule de calcul</param>
    ''' <param name="formuleCalcul">Formule de calcul</param>
    ''' <param name="nomChResultat">Nom du champs résultat</param>
    ''' <param name="descChResultat">Description de la correspondance résultat</param>
    ''' <returns>Correspondance calculée</returns>
    ''' <remarks></remarks>
    Public Function addSELECTcalculee(ByVal lnomsTraitementsSource() As String, _
                                      ByVal ldescCorrespFormule() As String, _
                                      ByVal formuleCalcul As String, _
                                      ByVal nomChResultat As String, _
                                      ByVal descChResultat As String) As Correspondance

        'Dim traitDateNaiss As Traitement = _ltraitementsSource(nomTraitDateNaiss)
        'Dim traitDateCalcul As Traitement = _ltraitementsSource(nomTraitDateCalcul)
        Dim correspResult As Correspondance = Nothing

        If Not ListeChampsSortie.ContainsKey(descChResultat) Then

            Dim champsSce As New ChampsBDD(formuleCalcul, _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            Dim champsCible As New ChampsBDD(nomChResultat, _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))

            correspResult = New Correspondance(Me, descChResultat, champsCible)
            correspResult.setChEntree(champsSce)

            For i As Integer = 0 To lnomsTraitementsSource.Count - 1
                Dim correspFormule As Correspondance = _ltraitementsSource.Item(lnomsTraitementsSource(i)).ListeChampsSortie.Item(ldescCorrespFormule(i))
                correspResult.addCorrespFormule(correspFormule)
            Next i
            addDependance(correspResult)
            ListeChampsSortie.addCorresp(correspResult)

            Me.invalideAll()

        End If
        Return correspResult
    End Function

    ''' <summary>
    ''' Ajout d'un champs calculé de type tranche dans la requête
    ''' </summary>
    ''' <param name="descrCorrespTranche"></param>
    ''' <param name="nomChOutilTranche"></param>
    ''' <param name="tableCorrespTranche"></param>
    ''' <param name="colMin"></param>
    ''' <param name="colMax"></param>
    ''' <param name="colVal"></param>
    ''' <param name="masque"></param>
    ''' <returns></returns>
    ''' <remarks>L'appel à cette fonction nécessite de paramétrer soi même les dépendances</remarks>
    Public Overloads Function addSELECTtranche(ByVal descrCorrespTranche As String, _
                                     ByVal nomChOutilTranche As String, _
                                     ByVal tableCorrespTranche As DataTable, _
                                     ByVal colMin As String, _
                                     ByVal colMax As String, _
                                     ByVal colVal As String, _
                                     Optional ByVal masque As String = "{1}") As ChampsTraitTranche

        Dim corresp As New ChampsTraitTranche(Me, _
                                              descrCorrespTranche, _
                                              nomChOutilTranche, _
                                              tableCorrespTranche, _
                                              colMin, _
                                              colMax, _
                                              colVal, _
                                              masque)
        ListeChampsSortie.addCorresp(corresp)
        invalideAll()
        Return corresp
    End Function

    Public Overloads Function addSELECTTranche(ByVal descrCorrespTranche As String, _
                                     ByVal nomChOutilTranche As String, _
                                     ByVal traitCorrespTranche As tableBDD, _
                                     ByVal colMin As String, _
                                     ByVal colMax As String, _
                                     ByVal colVal As String, _
                                     Optional ByVal masque As String = "{1}") As ChampsTraitTranche
        Dim corresp As New ChampsTraitTranche(Me, _
                                              descrCorrespTranche, _
                                              nomChOutilTranche, _
                                              traitCorrespTranche, _
                                              colMin, _
                                              colMax, _
                                              colVal, _
                                              masque)
        ListeChampsSortie.addCorresp(corresp)
        invalideAll()
        Return corresp
    End Function

    ''' <summary>
    ''' Ajout d'un champs calculé correspondant au calcul d'un âge exact entre deux dates présentes dans les traitements en entrée
    ''' </summary>
    ''' <param name="nomTraitDateNaiss"></param>
    ''' <param name="nomTraitDateCalcul"></param>
    ''' <param name="descDateCalcul"></param>
    ''' <param name="descDateNaiss"></param>
    ''' <param name="nomChResultat"></param>
    ''' <param name="descrChResultat"></param>
    ''' <remarks></remarks>
    Public Function addSELECTage(ByVal nomTraitDateNaiss As String, _
                            ByVal nomTraitDateCalcul As String, _
                            ByVal descDateCalcul As String, _
                            ByVal descDateNaiss As String, _
                            ByVal nomChResultat As String, _
                            ByVal descrChResultat As String) As Correspondance

        Dim traitDateNaiss As Traitement = _ltraitementsSource(nomTraitDateNaiss)
        Dim traitDateCalcul As Traitement = _ltraitementsSource(nomTraitDateCalcul)
        Dim correspage As Correspondance = Nothing

        If Not ListeChampsSortie.ContainsKey(nomChResultat) Then

            'Dim nomChDateNaiss = "", nomChDateCalcul As String = ""
            'If Not traitDateNaiss.mapSortie.item(descDateNaiss).chBDD Is Nothing Then
            'nomChDateNaiss = traitDateNaiss.mapSortie.item(descDateNaiss).chBDD.Nom
            'End If
            'If Not traitDateCalcul.mapSortie.item(descDateCalcul).chBDD Is Nothing Then
            'nomChDateCalcul = traitDateCalcul.mapSortie.item(descDateCalcul).chBDD.Nom
            'End If

            Dim champsSce As New ChampsBDD("({2}-{1})/365.25", _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            Dim champsCible As New ChampsBDD(nomChResultat, _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))

            correspage = New Correspondance(Me, descrChResultat, champsCible)
            correspage.setChEntree(champsSce)

            correspage.addCorrespFormule(traitDateNaiss.ListeChampsSortie.Item(descDateNaiss))
            correspage.addCorrespConstitutive(traitDateNaiss.ListeChampsSortie.Item(descDateNaiss))
            addDependance(traitDateNaiss.ListeChampsSortie.Item(descDateNaiss))

            correspage.addCorrespFormule(traitDateCalcul.ListeChampsSortie.Item(descDateCalcul))
            correspage.addCorrespConstitutive(traitDateCalcul.ListeChampsSortie.Item(descDateCalcul))
            addDependance(traitDateCalcul.ListeChampsSortie.Item(descDateCalcul))


            invalideAll()
            ListeChampsSortie.addCorresp(correspage)

        End If
        Return correspage
    End Function

    ''' <summary>
    ''' Ajout d'un champs calculé correspondant à la somme d'un champs d'un traitement source
    ''' </summary>
    ''' <remarks></remarks>
    Public Function addSELECTsum(ByVal nomTraitement As String, _
                            ByVal descChSum As String, _
                            ByVal nomChResultat As String, _
                            ByVal descChResultat As String, _
                            ByVal nomFormatAffSortie As String) As Correspondance

        Dim correspSUM As Correspondance = Nothing
        If Not ListeChampsSortie.ContainsKey(nomChResultat) Then

            Dim champsSce As New ChampsBDD("Sum({1})", _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            Dim champsCible As New ChampsBDD(nomChResultat, _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            champsCible.Format.formatAff = nomFormatAffSortie

            correspSUM = New Correspondance(Me, descChResultat, champsCible)
            correspSUM.setChEntree(champsSce)

            correspSUM.addCorrespFormule(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(descChSum))

            addDependance(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(descChSum))

            ListeChampsSortie.addCorresp(correspSUM)

            invalideAll()

        End If
        Return correspSUM
    End Function

    ''' <summary>
    ''' Ajout d'un champs calculé correspondant à la moyenne pondérée d'un champs d'un traitement source
    ''' </summary>
    ''' <remarks></remarks>
    Public Function addSELECTmoypond(ByVal nomTraitSceChMoyenne As String, _
                                ByVal nomTraitSceChPonderation As String, _
                                ByVal descChMoyenne As String, _
                                ByVal descChPonderation As String, _
                                ByVal nomChResultat As String, _
                                ByVal descChResultat As String, _
                                ByVal nomFormatAffSortie As String) As Correspondance

        Dim correspMOYPOND As Correspondance = Nothing
        If Not ListeChampsSortie.ContainsKey(nomChResultat) Then
            'Dim nomChMoyenne As String = item(descChMoyenne).chBDD.Nom
            'Dim nomChPonderation As String = item(descChPonderation).chBDD.Nom

            Dim champsSce As New ChampsBDD("Sum({1}*{2})/Sum({2})", _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            Dim champsCible As New ChampsBDD(nomChResultat, _
                New FormatChamps(Type.GetType("System.Double"), Type.GetType("System.Double")))
            champsCible.Format.formatAff = nomFormatAffSortie

            correspMOYPOND = New Correspondance(Me, descChResultat, champsCible)
            correspMOYPOND.setChEntree(champsSce)

            correspMOYPOND.addCorrespFormule(_ltraitementsSource(nomTraitSceChMoyenne).ListeChampsSortie.Item(descChMoyenne))
            correspMOYPOND.addCorrespFormule(_ltraitementsSource(nomTraitSceChPonderation).ListeChampsSortie.Item(descChPonderation))

            addDependance(_ltraitementsSource(nomTraitSceChMoyenne).ListeChampsSortie.Item(descChMoyenne))
            addDependance(_ltraitementsSource(nomTraitSceChPonderation).ListeChampsSortie.Item(descChPonderation))

            ListeChampsSortie.addCorresp(correspMOYPOND)

            invalideAll()

        End If
        Return correspMOYPOND
    End Function

    ''' <summary>
    ''' Supprime une correspondance de la clause SELECT
    ''' </summary>
    ''' <param name="nomCorrespondance">Nom de la correspondance à supprimer</param>
    ''' <remarks>A utiliser TRES PRECAUTIONNEUSEMENT car les dépendances ne gèrent pas encore les suppressions</remarks>
    Public Sub removeSELECT(ByVal nomCorrespondance As String)
        ListeChampsSortie.removeCorresp(nomCorrespondance)
        invalideAll()
    End Sub
    Public Sub clearSELECT(ByVal NomExclu As String)
        If ListeChampsSortie.Count <> 0 Then
            Dim lCorresp As New List(Of Correspondance)
            For Each c As Correspondance In ListeChampsSortie.Values
                If c.chOutil.Nom <> NomExclu Then
                    lCorresp.Add(c)
                End If
            Next
            For Each c As Correspondance In lCorresp
                ListeChampsSortie.removeCorresp(c.description)
            Next
        End If
        invalideAll()
    End Sub

    Public Sub ClearGROUPBY()
        _lstCorrespGroupBy.Clear()
        FonctionCalculDataTable.Invalider()
    End Sub

#End Region

#Region "La clause GROUP BY"

    Public Overloads Function addGROUPBY(ByVal nomCorresp As String)
        Dim nbOccurenceNom As Integer = 0
        Dim nomTraitement As String = ""
        For Each traitementSource As Traitement In _ltraitementsSource.Values
            If traitementSource.ListeChampsSortie.ContainsKey(nomCorresp) Then
                nbOccurenceNom = nbOccurenceNom + 1
                nomTraitement = traitementSource.nom
            End If
        Next
        If nbOccurenceNom = 1 Then
            addGROUPBY(nomTraitement, nomCorresp)
            Return True
        Else
            Return False
        End If
    End Function

    ''' <summary>
    ''' Ajout d'un champs dans la clause GROUP BY de la requête
    ''' </summary>
    ''' <param name="nomTraitement"></param>
    ''' <param name="nomCorresp"></param>
    ''' <remarks></remarks>
    Public Overloads Sub addGROUPBY(ByVal nomTraitement As String, ByVal nomCorresp As String)

        'Récupération de la correspondance et copie pour alimentation de la clause SELECT
        Dim correspGROUPBY As Correspondance = _ltraitementsSource(nomTraitement).ListeChampsSortie.Item(nomCorresp).copy()
        correspGROUPBY.setTraitement(Me)
        Dim chSource As ChampsBDD = New ChampsBDD("{1}", correspGROUPBY.chOutil.Format.copy)
        correspGROUPBY.setChEntree(chSource)
        _lstCorrespGroupBy.Add(correspGROUPBY.description, correspGROUPBY)

        correspGROUPBY.clearCorrespConstitutive()
        correspGROUPBY.clearCorrespFormule()

        correspGROUPBY.addCorrespFormule(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(nomCorresp))

        'Ajout de la correspondance source comme correspondance constitutive du nouveau champs créé en sortie
        'correspGROUPBY.addCorrespConstitutive(_ltraitementsSource(nomTraitement).mapSortie.item(nomCorresp))
        'Il faut également ajouter en correspondance constitutive toutes celles qui interviennent dans le group
        'BY ainsi que celle qui interviennent dans le WHERE (ou le HAVING d'ailleurs)

        'Interception, à l'intérieur du traitement, des messages d'invalidation du champs source
        addDependance(_ltraitementsSource(nomTraitement).ListeChampsSortie.Item(nomCorresp))


        'Ajout de la correspondance au mapping de sortie de la requête
        'Il s'agit du mapping dans lequel un traitement ultérieur ira récupérer ses champs
        'Le mapping de sortie en sortie contient la collection correspSELECT
        '_mapSortie.addCorresp(corresp)
        FonctionCalculDataTable.Invalider()
        'Interception de l'évènement "la correspondance a été modifiée"

        '_lstCorrespGroupBy.Add(corresp.description, corresp)
        '_lDependanceCorrespondances.Add(corresp)
        '_etatExecDataTable = etatCalcul.A_MAJ
    End Sub

    ''' <summary>
    ''' Supprime une correspondance de la clause GROUP BY
    ''' </summary>
    ''' <param name="nomCorrespondance">Nom de la correspondance à supprimer</param>
    ''' <remarks>A utiliser TRES PRECAUTIONNEUSEMENT car les dépendances ne gèrent pas encore les suppressions</remarks>
    Public Sub removeGROUPBY(ByVal nomCorrespondance As String)
        _lstCorrespGroupBy.Remove(nomCorrespondance)
        FonctionCalculDataTable.Invalider()
    End Sub

#End Region

#Region "La clause WHERE"
    ''' <summary>
    ''' Permet d'ajouter un filtre à la requête. L'utilisateur doit créer la
    ''' correspondance (calculée ou non) représentant le filtre
    ''' </summary>
    ''' <param name="key">Identifiant de la clause WHERE</param>
    ''' <param name="corresp">Correspondance représentant la formule de calcul du filtre</param>
    ''' <param name="operateur">Nature du test à effectuer sur la formule de calcul (combinaison de champs en entrée)</param>
    ''' <param name="valeur">Valeur à tester</param>
    ''' <remarks></remarks>
    Public Sub addWHERE(ByVal key As String, _
                        ByVal corresp As Correspondance, _
                        ByVal operateur As operateurFiltreBDD, _
                        ByVal valeur As String)
        'Ici, il faut vérifier que les traitements utilisés dans corresp sont bien des
        'traitements sources de la requête
        'Il faut également ajouter les champs sources de corresp comme impactants pour la requête
        Dim exprFiltre As expressionFiltreBDD = New expressionFiltreBDD(corresp, operateur, valeur)
        _lstWHERE.Add(key, exprFiltre)
        AddHandler exprFiltre.valeurAchange, AddressOf onValeurWHERE_HasChanged
        'Ajouter un champs permettant d'intercepter les changements de valeur du filtre afin
        'd'invalider la requête
        FonctionCalculDataTable.Invalider()
    End Sub
    ''' <summary>
    ''' Permet de récupérer un filtre appliqué à la requête en fonction du nom du champs sur lequel elle porte
    ''' </summary>
    ''' <remarks></remarks>
    Public Function getWHERE(ByVal key As String) As expressionFiltreBDD
        Return _lstWHERE(key)
    End Function
    ''' <summary>
    ''' La clause WHERE a changé
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub onValeurWHERE_HasChanged(ByVal obj As Object, ByVal e As EventArgs)
        Me.invalideAll()
    End Sub
#End Region

#Region "Les jointures"

    ''' <summary>
    ''' Ajoute une jointure à la requête
    ''' </summary>
    ''' <remarks></remarks>
    Public Function addJointure(ByVal nomLeftTraitement As String, _
                                ByVal lStrLeftCorresp As List(Of String), _
                                ByVal nomRightTraitement As String, _
                                ByVal lStrRightCorresp As List(Of String), _
                                ByVal typeJointure As typeJointure) As Boolean

        Dim lLeftCorresp As New List(Of Correspondance)
        Dim lRightCorresp As New List(Of Correspondance)

        For Each Str As String In lStrLeftCorresp
            lLeftCorresp.Add(_ltraitementsSource.Item(nomLeftTraitement).ListeChampsSortie.Item(Str))
        Next
        For Each Str As String In lStrRightCorresp
            lRightCorresp.Add(_ltraitementsSource.Item(nomRightTraitement).ListeChampsSortie.Item(Str))
        Next

        Dim jointure As New jointureBDD(_ltraitementsSource(nomLeftTraitement), _
                                        lLeftCorresp, _
                                        _ltraitementsSource(nomRightTraitement), _
                                        lRightCorresp, _
                                        typeJointure)
        _lstJointures.Add(jointure)

        Return True

    End Function
    ''' <summary>
    ''' Supprime toutes les jointures présentes sur la requête
    ''' </summary>
    ''' <remarks></remarks>
    Public Sub clearJointures()
        _lstJointures.Clear()
    End Sub

#End Region

#End Region

#Region "Génération du code SQL"

    ''' <summary>
    ''' Génère le code SQL correspondant à la requête
    ''' </summary>
    ''' <remarks></remarks>
    Private Function genereCodeSQL() As String

        'Indiquent si la requête contient une clause GROUP BY ainsi que des jointures
        Dim blnHasGroupBy As Boolean = _lstCorrespGroupBy.Count <> 0
        Dim blnHasJointures As Boolean = _lstJointures.Count <> 0

        'Initialisation des chaînes de caractères composant la requête
        Dim strQuery As String = ""
        Dim strQuerySELECT As String = ""
        Dim strQueryFROM As String = ""
        Dim strQueryGROUPBY As String = ""
        Dim strQueryWHERE As String = ""

        'Si la requête contient des jointures, on affecte un nom temporaire à chaque traitement source
        Dim i As Integer = 1
        For Each trait As Traitement In _ltraitementsSource.Values
            If blnHasJointures Then
                trait.tempNom = "T" & CStr(i)
            Else
                trait.tempNom = ""
            End If
            i = i + 1
        Next

        'Initialisation de la chaîne de caractère contenant le SELECT de la requête SQL
        'Permet de gérer les cas
        strQuerySELECT = "SELECT " & IIf(_nbEnregistrements <> 0, "TOP " & _nbEnregistrements & " ", "") _
                                   & IIf(_isDISTINCT, "DISTINCT ", "")
        For Each corresp As Correspondance In ListeChampsSortie.Values
            Dim b As Boolean
            b = False
            If Me.nom = "traitReqPrepTbleEncours1" And corresp.description = "Tranche de capitaux" Then b = True
            strQuerySELECT = strQuerySELECT & corresp.codeSQLSELECT & ","
        Next
        strQuerySELECT = Microsoft.VisualBasic.Left(strQuerySELECT, Len(strQuerySELECT) - 1) & vbCrLf


        'Init FROM
        strQueryFROM = genereFROM()

        If blnHasGroupBy Then
            'Init de la clause GROUP BY de la requête
            strQueryGROUPBY = " GROUP BY "
            For Each corresp As Correspondance In _lstCorrespGroupBy.Values
                strQueryGROUPBY = strQueryGROUPBY & corresp.codeSQLGROUPBY & ","
            Next
            strQueryGROUPBY = Microsoft.VisualBasic.Left(strQueryGROUPBY, Len(strQueryGROUPBY) - 1)
            If strQueryGROUPBY = " GROUP BY" Then strQueryGROUPBY = ""
        End If

        If _lstWHERE.Count <> 0 Then
            strQueryWHERE = " " & genereWHERE() & " "
        End If

        strQuery = strQuerySELECT & strQueryFROM & strQueryWHERE & strQueryGROUPBY & ";"

        Return strQuery
    End Function

    ''' <summary>
    ''' Génère la clause FROM du code SQL correspondant à la requête
    ''' </summary>
    ''' <remarks></remarks>
    Private Function genereFROM() As String
        'Init FROM
        'Etablissement de la liste des traitements intervenant dans la requête
        Dim b As Boolean = (nom = "traitReqPrepTbleEncours2")
        Dim strQueryFROM As String = " FROM "
        If Not _tbleSource Is Nothing Then
            strQueryFROM = strQueryFROM & _tbleSource.nomTableDansBDD & vbCrLf
        Else
            '2 cas, soit des jointures sont paramétrées sur la requête, soit on fait un produit cartésien
            If _lstJointures.Count = 0 Then
                'Produit cartésien
                For Each trait As Traitement In _ltraitementsSource.Values
                    strQueryFROM = strQueryFROM & trait.nomTableDansBDD & "," & vbCrLf
                    'Ajouter le code relatif aux jointures dépendant de ce traitement et marquer chacune
                    'des jointures comme traitée
                Next
                strQueryFROM = Microsoft.VisualBasic.Left(strQueryFROM, Len(strQueryFROM) - 3)
            Else
                'Jointures entre les traitements source
                For Each jointure As jointureBDD In _lstJointures
                    jointure.aEteTraitee = False
                Next
                strQueryFROM = strQueryFROM & genereFROMjointures(_lstJointures(0).leftTraitement.nomTableDansBDD & " AS " & _lstJointures(0).leftTraitement.tempNom, _lstJointures(0).leftTraitement.nom)
            End If
        End If
        Return strQueryFROM
    End Function

    ''' <summary>
    ''' Ajuste la clause FROM d'éventuelles jointures présentes sur la requête
    ''' </summary>
    ''' <remarks></remarks>
    Private Function genereFROMjointures(ByRef strFROM As String, ByVal nomTrait As String)

        'Le traitement source appartient-il à au moins une jointure de la requête
        For Each jointure As jointureBDD In _lstJointures

            If (jointure.leftTraitement.nom = nomTrait _
                    Or jointure.rightTraitement.nom = nomTrait) _
                And jointure.aEteTraitee = False Then

                'Ajout du type de jointure
                If jointure.typeJointure = typeJointure.DROITE Then
                    strFROM = strFROM & " RIGHT JOIN "
                ElseIf jointure.typeJointure = typeJointure.GAUCHE Then
                    strFROM = strFROM & " LEFT JOIN "
                Else
                    strFROM = strFROM & " INNER JOIN "
                End If

                'Ajout du nom de la table jointe
                Dim nomTraitTbleJoint As String = ""
                Dim nomTraitJoint As String = ""
                If nomTrait = jointure.leftTraitement.nom Then
                    nomTraitTbleJoint = jointure.rightTraitement.nomTableDansBDD & " AS " & jointure.rightTraitement.tempNom
                    nomTraitJoint = jointure.rightTraitement.nom
                End If
                If nomTrait = jointure.rightTraitement.nom Then
                    nomTraitTbleJoint = jointure.leftTraitement.nomTableDansBDD
                    nomTraitJoint = jointure.leftTraitement.nom & " AS " & jointure.leftTraitement.tempNom
                End If
                strFROM = strFROM & nomTraitTbleJoint & " "

                'Ajout des champs impliqués dans la jointure
                strFROM = strFROM & "ON " & jointure.genereON & " "
                jointure.aEteTraitee = True
                genereFROMjointures(strFROM, nomTraitJoint)
            End If
        Next
        Return strFROM
    End Function

    ''' <summary>
    ''' Génère la clause WHERE du code SQL correspondant à la requête
    ''' </summary>
    ''' <remarks></remarks>
    Private Function genereWHERE() As String
        Dim result As String = ""
        For Each clauseWHERE As expressionFiltreBDD In _lstWHERE.Values
            result = result & clauseWHERE.genereSQL() & " AND "
        Next
        Return "WHERE (" & Left(result, result.Length - 5) & ")"
    End Function

#End Region

#Region "Exécution de la requête"

    ''' <summary>
    ''' Lorsqu'une requête devient incalculable, sa table des résultats prend la valeur null
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub onEtatCalculDataTable_Changed() Handles Me.EtatCalculDataTableAChange
        If Me.EtatCalcul_DataTable <> ValueEtatCalcul.A_JOUR Then
            Me.SetDataTableResultat(Nothing)
        End If
    End Sub

    ''' <summary>
    ''' Vérifie que les traitements sources sont tous à jour dans la base de données
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Private Function execVerifTraitementsSources() As String
        Dim result As String = ""
        'Mise à jour de tous les traitements nécessaires au calcul de la requête
        'Normalement, cette fonction doit être prise en charge par la fonction de calcul
        For Each trait As Traitement In _ltraitementsSource.Values
            If trait.EtatCalcul_BDD <> ValueEtatCalcul.A_JOUR Then
                trait.Calculer_BDD()
            End If
        Next
        Return result
    End Function

    ''' <summary>
    ''' Vérifie que les formules de calcul des correspondances sont valides
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Private Function execVerifValiditeFormules() As String
        Dim result As String = ""
        'Ici on vérifie que toutes les correspondances des clauses SELECT et GROUP BY sont valides
        For Each corresp As Correspondance In ListeChampsSortie.Values
            corresp.MAJ_EtatCorresp()
            If corresp.etat <> Drawing.Color.Green Then
                result = result & "Le champs '" & corresp.description & "' n'est pas valide dans le traitement " & Me.nom & vbCrLf
            End If
        Next
        For Each corresp As Correspondance In _lstCorrespGroupBy.Values
            corresp.MAJ_EtatCorresp()
            If corresp.etat <> Drawing.Color.Green Then
                result = result & "Le champs '" & corresp.description & "' n'est pas valide dans le traitement " & Me.nom & vbCrLf
            End If
        Next
        Return result
    End Function

    ''' <summary>
    ''' Exécute la requête dans la base de données
    ''' </summary>
    ''' <remarks></remarks>
    Protected Overrides Sub execute_BDD()

        'Ici on vérifie que tous les traitements sources nécessaires à 
        'la requête sont à jour dans la base de données
        Dim msgExecution As String = ""
        msgExecution = execVerifTraitementsSources()
        If msgExecution = "" Then
            msgExecution = execVerifValiditeFormules()
        End If

        If msgExecution = "" And EtatCalcul_DataTable <> ValueEtatCalcul.A_JOUR Then
            Dim strQuery As String
            strQuery = genereCodeSQL()
            strQuery = "CREATE TABLE " & NomTableDansBDD & " AS " & strQuery

            Dim OleDbCommand As New OleDb.OleDbCommand()
            OleDbCommand.Connection = Connection
            OleDbCommand.CommandText = strQuery
            OleDbCommand.CommandType = CommandType.Text

            Connection.Open()
            OleDbCommand.ExecuteNonQuery()
            Connection.Close()
            FonctionCalculBDD.EstCalculable()
        Else
            FonctionCalculBDD.EstNonCalculable()
        End If
    End Sub

    ''' <summary>
    ''' Exécute la requête et stocke le résultat sous forme de DataTable
    ''' </summary>
    ''' <remarks></remarks>
    Protected Overrides Sub execute_DataTable()
        If EtatCalcul_DataTable <> ValueEtatCalcul.A_JOUR Then
            Me.SetDataTableResultat(execute_DataTable(0, 0))
            If Not _DataTableResultats Is Nothing Then
                _DataTableResultats.TableName = "dtble_" & nom
            End If
            If Not DataSet Is Nothing And Not (_DataTableResultats Is Nothing) Then
                If DataSet.Tables.Contains(_DataTableResultats.TableName) Then
                    DataSet.Tables.Remove(_DataTableResultats.TableName)
                End If
            End If
        End If
    End Sub

    ''' <summary>
    ''' Exécute la requête et renvoie le résultat sous forme de dataTable pour les lignes comprises entre
    ''' ligneDeb et ligneFin
    ''' </summary>
    ''' <param name="ligneDeb"></param>
    ''' <param name="nbLignes"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overloads Function execute_DataTable(ByVal ligneDeb As Integer, _
                                                ByVal nbLignes As Integer) _
                                                As DataTable
        'Ici on vérifie que tous les traitements sources nécessaires à 
        'la requête sont à jour dans la base de données
        Dim msgExecution As String = ""
        msgExecution = execVerifTraitementsSources()
        If msgExecution = "" Then
            msgExecution = execVerifValiditeFormules()
        End If

        Dim result As DataTable = Nothing

        '  Dim o = genereCodeSQL()

        If msgExecution = "" And ListeChampsSortie.Count <> 0 Then

            Dim strQuery As String = ""
            result = New DataTable("dtble_" & Me.nom)
            For Each corresp As Correspondance In ListeChampsSortie.Values
                result.Columns.Add(corresp.chOutil.Nom, corresp.chOutil.Format.typeStock)
            Next

            strQuery = genereCodeSQL()

            'Ouverture de la connection et exécution de la requête
            Dim myRow As DataRow
            Dim OleDbCommand As New OleDbCommand()
            OleDbCommand.Connection = Connection
            OleDbCommand.CommandText = strQuery
            OleDbCommand.CommandType = CommandType.Text

            Dim debut, fin As Double
            debut = Environment.TickCount

            Connection.Open()

            Dim reader As OleDbDataReader = OleDbCommand.ExecuteReader

            Dim formatStockChSortie As String
            Dim nomChSortie As String
            Dim i As Integer
            Dim numChamps As Integer = 1
            Dim nbChampsRecup As Integer = 0

            Dim resDouble As Double, resString As String, resDecimal As Decimal

            ''While reader.Read() And numChamps <= ligneDeb
            ''numChamps = numChamps + 1
            ''End While

            While reader.Read() ''And (nbChampsRecup < nbLignes Or nbChampsRecup = 0)

                nbChampsRecup = nbChampsRecup + 1
                'On crée une nouvelle ligne destinée à être insérée dans la table
                myRow = result.NewRow()
                i = 0

                For Each corresp As Correspondance In ListeChampsSortie.Values

                    'On crée une nouvelle colonne destinée à être ajoutée à la table résultat
                    formatStockChSortie = corresp.chOutil.Format.typeStock.Name
                    nomChSortie = corresp.chOutil.Nom

                    'Pour chaque type de données possible en sortie, on lit de manière différente
                    'le dataReader
                    If formatStockChSortie = "Double" Then
                        resDouble = CType(reader(i), Double)
                        If Not IsDBNull(resDouble) Then myRow(nomChSortie) = resDouble
                    ElseIf formatStockChSortie = "String" Then
                        resString = CType(reader(i), String)
                        If Not IsDBNull(resString) Then myRow(nomChSortie) = resString
                    ElseIf formatStockChSortie = "DateTime" Then
                        resDouble = CType(reader(i), Double)
                        If Not IsDBNull(resDouble) Then myRow(nomChSortie) = _
                        informatChampsBDD.convToDateTime(resDouble)
                    ElseIf formatStockChSortie = "Decimal" Then
                        resDecimal = CType(reader(i), Double)
                        If Not IsDBNull(resDecimal) Then myRow(nomChSortie) = resDecimal
                    End If
                    i = i + 1
                Next

                result.Rows.Add(myRow)

            End While

            ''''While reader.Read
            ''''result.Rows.Add(result.NewRow())
            ''''End While

            Connection.Close()

            fin = Environment.TickCount
            ''''MsgBox("Temps en secondes : " & (fin - debut) / 1000)

            'On renomme les headers de la dataTable
            For Each selectCorresp As Correspondance In ListeChampsSortie.Values
                result.Columns(selectCorresp.chOutil.Nom).Caption = selectCorresp.description
            Next

            'FonctionCalculDataTable.Invalider()

        End If

        FonctionCalculDataTable.EstCalculable()
        Return result
    End Function

    'Public Function execute_DataTableQUATRO() As DataTable

    '    Dim result As DataTable = Nothing
    '    Dim strQuery As String = ""
    '    'Dim correspNumColonnesNomChamps(_lstCorrespSelect.Count - 1, 1) As String

    '    'Ajouter la vérification que le traitement correspondant à la requête n'a pas déjà été exécuté

    '    'Init de la table résultat et de la chaîne de caractère contenant le SELECT de la requête SQL
    '    result = New DataTable("Rés" & Me.nom)
    '    For Each corresp As Correspondance In ListeChampsSortie.Values
    '        result.Columns.Add(corresp.chOutil.Nom, corresp.chOutil.Format.typeStock)
    '    Next

    '    strQuery = genereCodeSQL()

    '    'Ouverture de la connection et exécution de la requête
    '    Dim OleDbCommand As New OleDbCommand()
    '    Dim connection As OleDbConnection = _tbleSource.connection()
    '    OleDbCommand.Connection = _tbleSource.connection()
    '    OleDbCommand.CommandText = strQuery
    '    OleDbCommand.CommandType = CommandType.Text

    '    Dim debut, fin As Double
    '    debut = Environment.TickCount

    '    connection.Open()

    '    Dim reader As OleDbDataReader = OleDbCommand.ExecuteReader

    '    Dim formatStockChSortie As String = ""
    '    Dim nomChSortie As String = ""
    '    Dim i As Integer = 0, j As Integer
    '    j = 0
    '    Dim tab As New ArrayList

    '    'Afficher les premières lignes, lancer un thread qui enregistre les lignes restantes

    '    ''While j < 25000
    '    '' reader.Read()
    '    ''j = j + 1
    '    ''End While

    '    While reader.Read() ''''And j < 25250
    '        j = j + 1
    '        tab.Add(reader)
    '        'On crée une nouvelle ligne destinée à être insérée dans la table
    '        ''''myRow = result.NewRow()
    '        ''''i = 0

    '        ''''For Each corresp As Correspondance In _lstCorrespSelect.Values

    '        'On crée une nouvelle colonne destinée à être ajoutée à la table résultat
    '        ''''formatStockChSortie = corresp.getChSortie.getFormat.typeStock.Name
    '        ''''nomChSortie = corresp.getChSortie.Nom

    '        'Pour chaque type de données possible en sortie, on lit de manière différente
    '        'le dataReader
    '        ''''If Not IsDBNull(reader(i)) Then
    '        ''''If formatStockChSortie = "Double" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDouble(CType(reader(i), Double))
    '        ''''ElseIf formatStockChSortie = "String" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToString(CType(reader(i), String))
    '        ''''ElseIf formatStockChSortie = "DateTime" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDateTime(CType(reader(i), Double))
    '        ''''ElseIf formatStockChSortie = "Decimal" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDecimal(CType(reader(i), Decimal))
    '        ''''End If
    '        ''''End If
    '        ''''i = i + 1
    '        ''''Next

    '        ''''result.Rows.Add(myRow)

    '    End While

    '    connection.Close()

    '    fin = Environment.TickCount
    '    MsgBox("Temps en secondes : " & (fin - debut) / 1000)

    '    'On renomme les headers de la dataTable
    '    For Each selectCorresp As Correspondance In ListeChampsSortie.Values
    '        result.Columns(selectCorresp.chOutil.Nom).Caption = selectCorresp.description
    '    Next

    '    FonctionCalculDataTable.Invalider()

    '    Return result
    'End Function

    'Public Function execute_DataTableTER() As DataTable

    '    Dim result As DataTable = Nothing
    '    Dim strQuery As String = ""
    '    'Dim correspNumColonnesNomChamps(_lstCorrespSelect.Count - 1, 1) As String

    '    'Ajouter la vérification que le traitement correspondant à la requête n'a pas déjà été exécuté

    '    'Init de la table résultat et de la chaîne de caractère contenant le SELECT de la requête SQL
    '    result = New DataTable("Rés" & Me.nom)
    '    For Each corresp As Correspondance In ListeChampsSortie.Values
    '        result.Columns.Add(corresp.chOutil.Nom, corresp.chOutil.Format.typeStock)
    '    Next

    '    strQuery = genereCodeSQL()

    '    'Ouverture de la connection et exécution de la requête
    '    Dim OleDbCommand As New OleDbCommand()
    '    Dim connection As OleDbConnection = _tbleSource.connection()
    '    OleDbCommand.Connection = _tbleSource.connection()
    '    OleDbCommand.CommandText = strQuery
    '    OleDbCommand.CommandType = CommandType.Text

    '    Dim debut, fin As Double
    '    debut = Environment.TickCount

    '    connection.Open()

    '    Dim reader As OleDbDataReader = OleDbCommand.ExecuteReader

    '    Dim formatStockChSortie As String = ""
    '    Dim nomChSortie As String = ""
    '    Dim i As Integer = 0, j As Integer
    '    j = 0
    '    Dim tab As New ArrayList

    '    'Afficher les premières lignes, lancer un thread qui enregistre les lignes restantes

    '    ''While j < 25000
    '    '' reader.Read()
    '    ''j = j + 1
    '    ''End While

    '    While reader.Read() ''''And j < 25250
    '        j = j + 1
    '        tab.Add(reader)
    '        'On crée une nouvelle ligne destinée à être insérée dans la table
    '        ''''myRow = result.NewRow()
    '        ''''i = 0

    '        ''''For Each corresp As Correspondance In _lstCorrespSelect.Values

    '        'On crée une nouvelle colonne destinée à être ajoutée à la table résultat
    '        ''''formatStockChSortie = corresp.getChSortie.getFormat.typeStock.Name
    '        ''''nomChSortie = corresp.getChSortie.Nom

    '        'Pour chaque type de données possible en sortie, on lit de manière différente
    '        'le dataReader
    '        ''''If Not IsDBNull(reader(i)) Then
    '        ''''If formatStockChSortie = "Double" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDouble(CType(reader(i), Double))
    '        ''''ElseIf formatStockChSortie = "String" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToString(CType(reader(i), String))
    '        ''''ElseIf formatStockChSortie = "DateTime" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDateTime(CType(reader(i), Double))
    '        ''''ElseIf formatStockChSortie = "Decimal" Then
    '        ''''myRow(nomChSortie) = _
    '        ''''informatChampsBDD.convToDecimal(CType(reader(i), Decimal))
    '        ''''End If
    '        ''''End If
    '        ''''i = i + 1
    '        ''''Next

    '        ''''result.Rows.Add(myRow)

    '    End While

    '    connection.Close()

    '    fin = Environment.TickCount
    '    MsgBox("Temps en secondes : " & (fin - debut) / 1000)

    '    'On renomme les headers de la dataTable
    '    For Each selectCorresp As Correspondance In ListeChampsSortie.Values
    '        result.Columns(selectCorresp.chOutil.Nom).Caption = selectCorresp.description
    '    Next

    '    Return result
    'End Function

    'Public Function execute_DataTableBIS() As DataTable

    '    Dim result As DataTable = Nothing
    '    Dim strQuery As String = ""

    '    'Ajouter la vérification que le traitement correspondant à la requête n'a pas déjà été exécuté

    '    'Init de la table résultat et de la chaîne de caractère contenant le SELECT de la requête SQL
    '    result = New DataTable("Rés" & Me.nom)
    '    'For Each corresp As Correspondance In _lstCorrespSelect.Values
    '    'result.Columns.Add(corresp.getChSortie.Nom, corresp.getChSortie.getFormat.typeStock)
    '    'Next

    '    strQuery = genereCodeSQL()

    '    'Ouverture de la connection et exécution de la requête
    '    ''Dim myRow As DataRow
    '    ''Dim OleDbCommand As New OleDbCommand()
    '    ''Dim connection As OleDbConnection = _tbleSource.getConnection()
    '    ''OleDbCommand.Connection = _tbleSource.getConnection()
    '    ''OleDbCommand.CommandText = strQuery
    '    ''OleDbCommand.CommandType = CommandType.Text

    '    Dim debut, fin As Double
    '    debut = Environment.TickCount
    '    Dim ConnectionEnc As OleDbConnection = _tbleSource.connection

    '    ConnectionEnc.Open()

    '    ''_connection.ConnectionString = strQuery
    '    Dim da As New OleDbDataAdapter(strQuery, Connection)
    '    ''''result.CacheSize()
    '    da.Fill(result)
    '    ConnectionEnc.Close()

    '    fin = Environment.TickCount
    '    MsgBox("Temps en secondes : " & (fin - debut) / 1000)

    '    'On renomme les headers de la dataTable
    '    For Each selectCorresp As Correspondance In ListeChampsSortie.Values
    '        result.Columns(selectCorresp.chOutil.Nom).Caption = selectCorresp.description
    '    Next

    '    Return result
    'End Function
#End Region

End Class